﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using Microsoft.Office.Interop.Excel;
using System.IO;
using System.Diagnostics;
using System.Drawing;
using System.Data;
using System.Drawing.Printing;

namespace ReadAndWrite
{
    /// <summary>
    /// Permet de gerer un classeur Excel
    /// </summary>
    public class Excel : ReadAndWrite
    {
        #region Attributs

        _Application app;
        string fileName;
        private int processId;

        #endregion

        #region Constructeur

        /// <summary>
        /// Contructeur : Creer un objet Excel
        /// </summary>
        public Excel()
        {
            Process[] ExcelProcessesBefore = Process.GetProcessesByName("EXCEL");
            app = new Application();
            Process[] ExcelProcessesAfter = Process.GetProcessesByName("EXCEL");
            processId = GetProcessId(ExcelProcessesBefore, ExcelProcessesAfter);
        }

        #endregion

        #region Flux Ouverture , Fermeture, Import etc ..

        /// <summary>
        /// Ouverture du fichier selon le chemin passé en paramètre
        /// </summary>
        /// <param name="Path">Chemin du fichier</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool Ouvrir(string Path)
        {
            try
            {
                app.Workbooks.Open(Path, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                    Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
                Path = System.IO.Path.GetFullPath(Path);
                fileName = System.IO.Path.GetFileName(Path);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ouverture du fichier vide
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool Ouvrir()
        {
            try
            {
                app.Workbooks.Add(1);
                Path = app.Workbooks[1].Path;
                this.fileName = app.Workbooks[1].Name;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Importation d'un fichier CSV dans un fichier Excel
        /// </summary>
        /// <param name="importFileName">Nom du fichier CSV</param>
        /// <param name="ligneDebut"></param>
        /// <param name="ligneFin"></param>
        /// <param name="colonneDebut"></param>
        /// <param name="colonneFin"></param>
        public void ImportCSV(string importFileName, long ligneDebut, long ligneFin, long colonneDebut, long colonneFin, int[] columnDataTypes)
        {
            Worksheet destinationSheet = (Worksheet)app.Workbooks[fileName].ActiveSheet;
            Range obj = destinationSheet.get_Range(destinationSheet.Cells[ligneDebut, colonneDebut], destinationSheet.Cells[ligneFin, colonneFin]);

            destinationSheet.QueryTables.Add("TEXT;" + System.IO.Path.GetFullPath(importFileName), obj, Type.Missing);
            destinationSheet.QueryTables[1].Name = System.IO.Path.GetFileNameWithoutExtension(importFileName);
            destinationSheet.QueryTables[1].FieldNames = true;
            destinationSheet.QueryTables[1].RowNumbers = false;
            destinationSheet.QueryTables[1].FillAdjacentFormulas = false;
            destinationSheet.QueryTables[1].PreserveFormatting = true;
            destinationSheet.QueryTables[1].RefreshOnFileOpen = false;
            destinationSheet.QueryTables[1].RefreshStyle = XlCellInsertionMode.xlInsertDeleteCells;
            destinationSheet.QueryTables[1].SavePassword = false;
            destinationSheet.QueryTables[1].SaveData = true;
            destinationSheet.QueryTables[1].AdjustColumnWidth = true;
            destinationSheet.QueryTables[1].RefreshPeriod = 0;
            destinationSheet.QueryTables[1].TextFilePromptOnRefresh = false;
            destinationSheet.QueryTables[1].TextFilePlatform = -535;
            destinationSheet.QueryTables[1].TextFileStartRow = 1;
            destinationSheet.QueryTables[1].TextFileParseType = XlTextParsingType.xlDelimited;
            destinationSheet.QueryTables[1].TextFileTextQualifier = XlTextQualifier.xlTextQualifierDoubleQuote;
            destinationSheet.QueryTables[1].TextFileConsecutiveDelimiter = false;
            destinationSheet.QueryTables[1].TextFileTabDelimiter = false;
            destinationSheet.QueryTables[1].TextFileSemicolonDelimiter = false;
            destinationSheet.QueryTables[1].TextFileCommaDelimiter = false;
            destinationSheet.QueryTables[1].TextFileSpaceDelimiter = false;
            destinationSheet.QueryTables[1].TextFileOtherDelimiter = ";";
            destinationSheet.QueryTables[1].TextFileColumnDataTypes = columnDataTypes;

            destinationSheet.QueryTables[1].Refresh(false);

            // cleanup
            destinationSheet.QueryTables[1].Delete();
        }

        /// <summary>
        /// Met le fichier en lecture seule
        /// </summary>
        /// <param name="value"></param>
        /// <param name="FullPathName"></param>
        public void LectureSeule(bool value, string FullPathName)
        {
            FileInfo cInfo = new FileInfo(FullPathName);
            cInfo.IsReadOnly = value;
        }

        /// <summary>
        /// Met le fichier en lecture seule
        /// </summary>
        /// <param name="value"></param>
        public void LectureSeule(bool value)
        {
            FileInfo cInfo = new FileInfo(app.Workbooks[fileName].FullName);
            cInfo.IsReadOnly = value;
        }

        /// <summary>
        /// Rend l'application Excel visible
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool AfficherExcel()
        {
            try
            {
                app.Visible = true;
                return app.Visible;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Rend l'application Excel invisible
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool CacherExcel()
        {
            try
            {
                app.Visible = false;
                return app.Visible;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Gèle l'application Excel
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool GelerExcel()
        {
            try
            {
                app.ScreenUpdating = false;
                app.EnableEvents = false;
                return app.ScreenUpdating;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Dégèle l'application Excel
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool DeGelerExcel()
        {
            try
            {
                app.ScreenUpdating = true;
                app.EnableEvents = true;
                return app.ScreenUpdating;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Désactive les aletes
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool DesactiverAlerts()
        {
            try
            {
                app.DisplayAlerts = false;
                return app.DisplayAlerts;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Active les alertes
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool ActiverAlerts()
        {
            try
            {
                app.DisplayAlerts = true;
                return app.DisplayAlerts;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ferme le fichier
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool Fermer()
        {
            try
            {
                app.Workbooks[fileName].Close(XlSaveAction.xlSaveChanges, Type.Missing, Type.Missing);
                return true;
            }
            catch (Exception) { throw; }

        }

        /// <summary>
        /// Ferme le fichier indiqué
        /// </summary>
        /// <param name="name">fichier à fermer.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool Fermer(string name)
        {
            try
            {
                app.Workbooks[name].Close(XlSaveAction.xlSaveChanges, Type.Missing, Type.Missing);
                return true;
            }
            catch (Exception) { throw; }

        }

        /// <summary>
        /// Quitte l'application Excel
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool Quitter()
        {
            try
            {
                app.Quit();
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Enregistre le fichier
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool Enregistrer()
        {
            try
            {
                app.DisplayAlerts = false;
                app.Workbooks[fileName].Save();
                return true;
            }
            catch (Exception) { throw; }

        }

        /// <summary>
        /// Enregistre suivant le chemin indiqué
        /// </summary>
        /// <param name="Path">Chemin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool Enregistrer(string Path)
        {
            try
            {
                app.Workbooks[fileName].SaveAs(Path, XlFileFormat.xlWorkbookNormal, Type.Missing, Type.Missing, Type.Missing,
                           Type.Missing, XlSaveAsAccessMode.xlNoChange, Type.Missing,
                           Type.Missing, Type.Missing, Type.Missing, Type.Missing);
                Path = System.IO.Path.GetFullPath(Path);
                fileName = System.IO.Path.GetFileName(Path);
                return true;
            }
            catch (Exception ex) { throw ex; }

        }

        /// <summary>
        /// Enregistre le fichier sous forme HTML
        /// </summary>
        /// <param name="Path">Chemin.</param>
        /// <param name="fileName">Nom du fichier.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool EnregistrerHTML(string Path, string fileName)
        {
            try
            {
                app.Workbooks[this.fileName].SaveAs(Path + fileName, XlFileFormat.xlHtml, Type.Missing, Type.Missing, Type.Missing,
                           Type.Missing, XlSaveAsAccessMode.xlNoChange, Type.Missing,
                           Type.Missing, Type.Missing, Type.Missing, Type.Missing);
                return true;
            }
            catch (Exception) { throw; }

        }

        /// <summary>
        /// Ouvre la boîte de dialogue pour l'impression
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool Imprimer()
        {
            app.Visible = true;
            app.Dialogs[XlBuiltInDialog.xlDialogPrint].Show(Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                Type.Missing, Type.Missing, Type.Missing);
            //app.Workbooks[fileName].PrintOut(Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
            return true;
        }

        /// <summary>
        /// Imprime directement sur l'imprimante par défaut
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool ImprimerDirect()
        {
            Worksheet wk = (Worksheet)app.Workbooks[fileName].ActiveSheet;
            PrinterSettings settings = new PrinterSettings();
            app.Workbooks[fileName].PrintOut(Type.Missing, Type.Missing, 1, false, settings.PrinterName, Type.Missing, Type.Missing, Type.Missing);
            return true;
        }

        /// <summary>
        /// Imprime sur toutes les imprimantes répertoriées en paramètre (à partir du fichier de configuration)
        /// qui sont également présentes sur le poste utilisateur
        /// </summary>
        /// <param name="listeImprimantes">Liste des imprimantes.</param>
        /// <returns>La liste des imprimantes sur lesquelles l'impression a été effectuée</returns>
        public IList<string> ImprimerSurListeImprimantes(System.Collections.Specialized.StringCollection listeImprimantes)
        {
            List<string> listeImprimanteSurPoste = new List<string>();

            IEnumerator cur = System.Drawing.Printing.PrinterSettings.InstalledPrinters.GetEnumerator();
            while (cur.MoveNext())
            {
                listeImprimanteSurPoste.Add(Convert.ToString(cur.Current).ToUpper());
            }

            IList<string> ListeImpressionsEffectuees = new List<string>();
            Worksheet wk = (Worksheet)app.Workbooks[fileName].ActiveSheet;
            foreach (string imprimante in listeImprimantes)
            {
                if (listeImprimanteSurPoste.Contains(imprimante.ToUpper()))
                {
                    //app.Workbooks[fileName].PrintOut(Type.Missing, Type.Missing, Type.Missing, Type.Missing, imprimante, Type.Missing, Type.Missing, Type.Missing);
                    app.Workbooks[fileName].PrintOut(Type.Missing, Type.Missing, 1, Type.Missing, imprimante, Type.Missing, Type.Missing, Type.Missing);
                    ListeImpressionsEffectuees.Add(imprimante);
                }
            }
            return ListeImpressionsEffectuees;
        }

        #endregion

        #region Créer feuille 

        /// <summary>
        /// Crée une nouvelle feuille Excel
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool CreerUneFeuille()
        {
            try
            {
                app.Workbooks[fileName].Sheets.Add(null, null, null, null);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Crée une nouvelle feuille 
        /// </summary>
        /// <param name="libelle">Libellé.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool CreerUneFeuille(string libelle)
        {
            return CreerUneFeuille(string.Empty, libelle);
        }

        /// <summary>
        /// Crée une nouvelle feuille
        /// </summary>
        /// <param name="name">Nom (code nom).</param>
        /// <param name="libelle">Libellé.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool CreerUneFeuille(string name, string libelle)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].Sheets.Add(null, null, null, null);
                if (!string.IsNullOrEmpty(name))
                {
                    feuille._CodeName = name;
                }
                feuille.Name = libelle;
                return true;
            }
            catch (Exception) { throw; }
        }

        #endregion

        #region Ecrire + Lecture

        /// <summary>
        /// Ecrit la valeur spéecifiée dans la cellule indiquée
        /// </summary>
        /// <param name="ligne">Ligne de la cellule.</param>
        /// <param name="colonne">Colonne de la cellule.</param>
        /// <param name="valeur">Valeur à inscrire.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool EcrireDansCellule(long ligne, long colonne, string valeur)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligne, colonne], feuille.Cells[ligne, colonne]);
                obj.FormulaR1C1 = valeur;
                //feuille.Cells[ligne, colonne] = valeur;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ecrit la valeur spéecifiée dans la cellule indiquée
        /// </summary>
        /// <param name="ligne">Ligne de la cellule.</param>
        /// <param name="colonne">Colonne de la cellule.</param>
        /// <param name="valeur">Valeur à inscrire.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool EcrireDansCelluleValue(long ligne, long colonne, string valeur)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligne, colonne], feuille.Cells[ligne, colonne]);
                obj.Value2 = valeur;
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Lit la valeur de la cellule indiquée
        /// </summary>
        /// <param name="ligne">Ligne de la cellule.</param>
        /// <param name="colonne">Colonne de la cellule.</param>
        /// <returns>Valeur lue.</returns>
        public string LireCellule(long ligne, long colonne)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                return Convert.ToString(((Range)feuille.Cells[ligne, colonne]).FormulaR1C1);
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Lit la valeur de la cellule indiquée ( le texte)
        /// </summary>
        /// <param name="ligne">Ligne de la cellule.</param>
        /// <param name="colonne">Colonne de la cellule.</param>
        /// <returns>Valeur lue.</returns>
        public string LireCelluleTexte(long ligne, long colonne)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                return Convert.ToString(((Range)feuille.Cells[ligne, colonne]).Text);
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Insère une nouvelle ligne à la ligne indiquée
        /// </summary>
        /// <param name="ligne">Ligne.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool InsererUneLigne(string ligne)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj = feuille.get_Range(ligne + ":" + ligne, Type.Missing);
                obj.EntireRow.Insert(Microsoft.Office.Interop.Excel.XlInsertShiftDirection.xlShiftDown, Type.Missing);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Supprime la ligne indiquée
        /// </summary>
        /// <param name="ligne">Ligne.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool SupprimerUneLigne(string ligne)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj = feuille.get_Range(ligne + ":" + ligne, Type.Missing);
                obj.EntireRow.Delete(Microsoft.Office.Interop.Excel.XlInsertShiftDirection.xlShiftDown);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Mise en forme du number format sur une cellule
        /// </summary>
        /// <param name="ligneDebut"></param>
        /// <param name="colonneDebut"></param>
        /// <returns></returns>
        public bool InsererCelluleDecalerADroite(long ligne, long colonne)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligne, colonne], feuille.Cells[ligne, colonne]);
                obj.Insert(XlDirection.xlToRight, Type.Missing);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Insère une image
        /// </summary>
        /// <param name="ligne">Ligne.</param>
        /// <param name="colonne">Colonne.</param>
        /// <param name="name">Nom de l'image.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool InsererImage(long ligne, long colonne, string name)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj = feuille.get_Range(feuille.Cells[ligne, colonne], feuille.Cells[ligne, colonne]);
                double top = Convert.ToDouble(obj.Top);
                double left = Convert.ToDouble(obj.Left);
                Shape img = feuille.Shapes.AddPicture(name, Microsoft.Office.Core.MsoTriState.msoFalse, Microsoft.Office.Core.MsoTriState.msoCTrue, (float)left, (float)top, 160, 96);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ajout le filigrane passé en paramètre
        /// </summary>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool Filigrane(string filigrane)
        {
            try
            {

                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;

                Shape shape = feuille.Shapes.AddTextEffect(Microsoft.Office.Core.MsoPresetTextEffect.msoTextEffect1, filigrane, "impact",
                    80, Microsoft.Office.Core.MsoTriState.msoFalse,
                    Microsoft.Office.Core.MsoTriState.msoFalse, 150, 300);


                shape.Fill.Visible = Microsoft.Office.Core.MsoTriState.msoTrue;
                shape.Fill.Solid();
                shape.Fill.ForeColor.SchemeColor = 22;
                shape.Fill.Transparency = 0.5f;
                shape.Line.Weight = 1;
                shape.Line.Visible = Microsoft.Office.Core.MsoTriState.msoFalse;
                shape.IncrementRotation(-30);

                return true;
            }
            catch (Exception) { throw; }

        }
        #endregion

        #region Formattage des données

        /// <summary>
        /// Ajuste automatiquement les colonnes indiquées
        /// </summary>
        /// <param name="debut">Première colonne à ajuster.</param>
        /// <param name="fin">Dernière colonne à ajuster.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool AutoFitColonne(long debut, long fin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;

                foreach (Range rg in feuille.Columns)
                {
                    if (rg.Column >= debut & rg.Column <= fin)
                    {
                        rg.EntireColumn.AutoFit();
                    }
                    if (rg.Column > fin)
                    {
                        break;
                    }
                }
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Vérifie si la (le groupe de) colonne(s) possède au moins la largueur indiquée,
        /// et affecte proportionnellement la bonne largeur si besoin.
        /// </summary>
        /// <param name="colDebut">Première colonne.</param>
        /// <param name="colFin">Dernière colonne.</param>
        /// <param name="largeurMin">Largeur minimale.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public long LargeurMinimum(long ligne, long colDebut, long colFin, long largeurMin)
        {
            try
            {
                long delta = 0;
                if (colDebut > colFin)
                {
                    throw new InvalidDataException("La colonne debut ne peut pas être suppérieur à la colonne fin.");
                }

                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                long largeurActuelle = 0;

                while (largeurActuelle < largeurMin)
                {

                    // Calcul largeur actuelle
                    foreach (Range rg in feuille.Columns)
                    {
                        if (rg.Column >= colDebut & rg.Column <= colFin)
                        {
                            largeurActuelle += Convert.ToInt64(rg.ColumnWidth);
                            if (rg.Column == colFin)
                            {
                                break;
                            }
                        }
                    }

                    // Régulation des colonnes si largeur actuelle insuffisante
                    if (largeurActuelle < largeurMin)
                    {
                        if (colDebut == colFin)
                        {
                            colFin++;
                            InsererCelluleDecalerADroite(ligne, colFin);
                        }
                        else
                        {
                            InsererCelluleDecalerADroite(ligne, colFin);
                            colFin++;
                        }
                        delta++;
                        largeurActuelle = 0;
                    }
                    else
                    {
                        break;
                    }
                }
                return delta;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ajuste automatiquement la ligne indiquée
        /// </summary>
        /// <param name="ligne">Ligne à ajuster.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool AutoFitLigne(long ligne)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                feuille.get_Range(ligne + ":" + ligne, Type.Missing).EntireRow.WrapText = true;
                feuille.get_Range(ligne + ":" + ligne, Type.Missing).EntireRow.VerticalAlignment = XlVAlign.xlVAlignCenter;
                feuille.get_Range(ligne + ":" + ligne, Type.Missing).EntireRow.HorizontalAlignment = XlHAlign.xlHAlignCenter;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Mise en forme du number format sur une cellule
        /// </summary>
        /// <param name="ligneDebut"></param>
        /// <param name="colonneDebut"></param>
        /// <returns></returns>
        public bool NumberFormatCellule(long ligne, long colonne, string numbertFormat)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligne, colonne], feuille.Cells[ligne, colonne]);
                obj.NumberFormat = numbertFormat;
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Fusionne les cellules
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool FusionCellule(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.Merge(Type.Missing);
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Fusionne les cellules
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool DeFusionCellule(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.UnMerge();
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Centre à droite
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool CentrerADroite(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.HorizontalAlignment = XlHAlign.xlHAlignRight;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Centre à gauche
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool CentrerAGauche(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.HorizontalAlignment = XlHAlign.xlHAlignLeft;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Formatter d'une plage de cellule (police,gras,souligner, ....)
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <param name="police"></param>
        /// <param name="taille"></param>
        /// <param name="gras"></param>
        /// <param name="souligner"></param>
        /// <returns></returns>
        public bool FormatterCellule(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin, string police, int taille, bool gras, bool souligner)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.Font.Name = police;
                obj.Font.Size = taille;
                obj.Font.Bold = gras;
                obj.Font.Underline = souligner;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Formatter une cellule (police,gras,souligner, ....)
        /// </summary>
        /// <param name="ligne"></param>
        /// <param name="colonne"></param>
        /// <param name="police"></param>
        /// <param name="taille"></param>
        /// <param name="gras"></param>
        /// <param name="souligner"></param>
        /// <returns></returns>
        public bool FormatterCellule(long ligne, long colonne, string police, int taille, bool gras, bool souligner)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligne, colonne], feuille.Cells[ligne, colonne]);
                obj.Font.Name = police;
                obj.Font.Size = taille;
                obj.Font.Bold = gras;
                obj.Font.Underline = souligner;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Mets en gras une place de cellule
        /// </summary>
        /// <param name="ligneDebut"></param>
        /// <param name="colonneDebut"></param>
        /// <param name="ligneFin"></param>
        /// <param name="colonneFin"></param>
        /// <param name="gras"></param>
        /// <returns></returns>
        public bool MettreEnGras(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin, bool gras)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.Font.Bold = gras;

                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Modifie la police d'une plage de cellule
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool ModifierPolice(long ligneDebut, long ligneFin, long colonneDebut, long colonneFin, string name, int size)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.Font.Name = name;
                obj.Font.Size = size;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Modifie la police d'une cellule
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool ModifierPolice(long ligne, long colonne, string name, int size)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligne, colonne], feuille.Cells[ligne, colonne]);
                obj.Font.Name = name;
                obj.Font.Size = size;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Centre
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool Centrer(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.HorizontalAlignment = XlHAlign.xlHAlignCenter;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Centre verticalement Horizontalement et verticalement
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool CentrerVertiHori(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.HorizontalAlignment = XlHAlign.xlHAlignCenter;
                obj.VerticalAlignment = XlVAlign.xlVAlignCenter;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Réalise un encadré fin
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool EncadrerFin(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.Borders[XlBordersIndex.xlEdgeTop].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeTop].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlThin;
                obj.Borders[XlBordersIndex.xlEdgeBottom].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeBottom].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlThin;
                obj.Borders[XlBordersIndex.xlEdgeLeft].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeLeft].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlThin;
                obj.Borders[XlBordersIndex.xlEdgeRight].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeRight].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlThin;


                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Réalise un encadré moyen
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool EncadrerMoyen(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.Borders[XlBordersIndex.xlEdgeTop].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeTop].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlMedium;
                obj.Borders[XlBordersIndex.xlEdgeBottom].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeBottom].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlMedium;
                obj.Borders[XlBordersIndex.xlEdgeLeft].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeLeft].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlMedium;
                obj.Borders[XlBordersIndex.xlEdgeRight].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeRight].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlMedium;

                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Réalise un encadré gros
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool EncadrerGros(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.Borders[XlBordersIndex.xlEdgeTop].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeTop].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlThick;
                obj.Borders[XlBordersIndex.xlEdgeBottom].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeBottom].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlThick;
                obj.Borders[XlBordersIndex.xlEdgeLeft].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeLeft].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlThick;
                obj.Borders[XlBordersIndex.xlEdgeRight].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlEdgeRight].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlThick;

                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Réalise un cadrillage intérieur fin
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool CadrillageIntérieurFin(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.Borders[XlBordersIndex.xlInsideHorizontal].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlThin;
                obj.Borders[XlBordersIndex.xlInsideVertical].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlContinuous;
                obj.Borders[XlBordersIndex.xlInsideVertical].Weight = Microsoft.Office.Interop.Excel.XlBorderWeight.xlThin;

                return true;
            }
            catch (Exception) { throw; }
        }


        /// Supprime tout cadrillages / traits
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool SupprTraits(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.Borders[XlBordersIndex.xlInsideHorizontal].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlLineStyleNone;
                obj.Borders[XlBordersIndex.xlInsideVertical].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlLineStyleNone;
                obj.Borders[XlBordersIndex.xlEdgeTop].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlLineStyleNone;
                obj.Borders[XlBordersIndex.xlEdgeBottom].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlLineStyleNone;
                obj.Borders[XlBordersIndex.xlEdgeLeft].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlLineStyleNone;
                obj.Borders[XlBordersIndex.xlEdgeRight].LineStyle = Microsoft.Office.Interop.Excel.XlLineStyle.xlLineStyleNone;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ajouter une couleur de font dans une cellule
        /// </summary>
        /// <param name="ligne">Numéro de ligne.</param>
        /// <param name="colonne">Numéro de colonne.</param>
        /// <param name="couleur">La couleur.</param>
        public void CouleurCellule(long ligne, long colonne, Color couleur)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                feuille.get_Range(feuille.Cells[ligne, colonne], feuille.Cells[ligne, colonne]).Cells.Interior.Color = System.Drawing.ColorTranslator.ToOle(couleur);
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ajouter une couleur de font dans une plage de cellule
        /// </summary>
        /// <param name="ligneDebut"></param>
        /// <param name="colonneDebut"></param>
        /// <param name="ligneFin"></param>
        /// <param name="colonneFin"></param>
        /// <param name="couleur"></param>
        public void CouleurCellule(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin, Color couleur)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]).Cells.Interior.Color = System.Drawing.ColorTranslator.ToOle(couleur);
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Fonction qui retourne la liste des HPageBreak
        /// </summary>
        /// <param name="debut">Ligne début.</param>
        /// <param name="fin">Ligne fin.</param>
        /// <returns></returns>
        public int[] GetHPageBreak(long ligneDebut, long ligneFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                int[] pageBreak = new int[feuille.HPageBreaks.Count];
                int nb = 0;

                foreach (HPageBreak pb in feuille.HPageBreaks)
                    if (pb.Location.Row >= ligneDebut && pb.Location.Row < ligneFin)
                        pageBreak[nb++] = pb.Location.Row;

                return pageBreak;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Savoir s'il y a un saut de page
        /// </summary>
        /// <param name="debut">Ligne début.</param>
        /// <param name="fin">Ligne fin.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool SautDePagePresenteEntre(long debut, long fin)
        {
            try
            {
                bool val_ret = false;
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;

                app.ScreenUpdating = true;
                // Sélection de la dernière ligne car certains HPageBreaks ne seront accessibles qu'une fois que leur ligne ait été parcourue
                feuille.get_Range(feuille.Rows.Count + ":" + feuille.Rows.Count, Type.Missing).Select();

                foreach (HPageBreak pb in feuille.HPageBreaks)
                {
                    if (pb.Location.Row >= debut && pb.Location.Row < fin)
                    {
                        val_ret = true;
                        break;
                    }
                }
                feuille.get_Range(feuille.Cells[1, 1], feuille.Cells[1, 1]).Select();
                app.ScreenUpdating = false;
                return val_ret;
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// Insère un saut de page à la ligne indiquée
        /// </summary>
        /// <param name="ligne">Ligne.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool InsertionSautDePage(long ligne)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                feuille.HPageBreaks.Add(feuille.Cells[ligne, 1]);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Autofit largeurMax page max en largeur et hauteurMax pages max en hauteur.
        /// Plus de zoom afin d'éviter une interprétation différente selon les imprimantes.
        /// </summary>
        /// <returns></returns>
        public bool SuppSautDePageVertical(int largeurMax, int hauteurMax)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                feuille.PageSetup.Zoom = false;
                feuille.PageSetup.FitToPagesTall = hauteurMax;
                feuille.PageSetup.FitToPagesWide = largeurMax;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Retourne le numéro de la dernière colonne possédant 
        /// au moins une cellule renseignée (même si les cellules sont fusionnées)
        /// </summary>
        /// <returns></returns>
        public int DerniereColonneRenseignee()
        {
            Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
            int max = 0;
            // Parcours de la première ligne à la dernière ligne renseignée
            for (int i = 1; i < feuille.get_Range("A65536", Type.Missing).get_End(XlDirection.xlUp).Row; ++i)
            {
                // Dernière colonne renseignée pour la ligne en cours
                Range tempLastRange = feuille.get_Range("IV" + i, Type.Missing).get_End(XlDirection.xlToLeft);
                // Le numéro de colonne + le nombre de cellules fusionnées - 1
                // "-1" car une cellule seule vaut 1 cellule fusionnée
                int tempLastCol = tempLastRange.Column + tempLastRange.MergeArea.Count - 1;
                if (max < tempLastCol)
                {
                    max = tempLastCol;
                }
            }
            return max;
        }

        /// <summary>
        /// Oriente de façon paysage
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool OrientationPaysage()
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                feuille.PageSetup.Orientation = XlPageOrientation.xlLandscape;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Oriente de façon portrait
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool OrientationPortrait()
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                feuille.PageSetup.Orientation = XlPageOrientation.xlPortrait;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Applique l'ordre des pages d'abord horizontalement, puis verticalement.
        /// </summary>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool OrdreDesPagesDroitePuisBas()
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                feuille.PageSetup.Order = XlOrder.xlOverThenDown;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Modifie la hauteur de la ligne indiquée
        /// </summary>
        /// <param name="ligne">Ligne.</param>
        /// <param name="hauteur">Hauteur.</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool HauteurLigne(long ligne, int hauteur)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                feuille.get_Range(ligne + ":" + ligne, Type.Missing).EntireRow.RowHeight = hauteur;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Colorier une plage de cellule ( Font )
        /// </summary>
        /// <param name="ligneDebut">Ligne début.</param>
        /// <param name="colonneDebut">Colonne début.</param>
        /// <param name="ligneFin">Ligne fin.</param>
        /// <param name="colonneFin">Colonne fin.</param>
        /// <param name="color">Couleur</param>
        /// <returns>Booléen indiquant si tout s'est bien déroulé.</returns>
        public bool ColorierFont(long ligneDebut, long colonneDebut, long ligneFin, long colonneFin, System.Drawing.Color color)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;
                obj = feuille.get_Range(feuille.Cells[ligneDebut, colonneDebut], feuille.Cells[ligneFin, colonneFin]);
                obj.Font.Color = System.Drawing.ColorTranslator.ToOle(color);
                return true;
            }
            catch (Exception) { throw; }
        }

        public void ColumnWidth(int numero, int height)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                foreach (Range rg in feuille.Columns)
                {
                    if (rg.Column == numero)
                    {
                        rg.EntireColumn.ColumnWidth = height;
                        break;
                    }
                }
            }
            catch (Exception) { throw; }
        }

        public void Sort(long ligneDebut, long colDebut, long ligneFin, long colFin)
        {
            try
            {
                Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
                Range obj;

                obj = feuille.get_Range(feuille.Cells[ligneDebut, colDebut], feuille.Cells[ligneFin, colFin]);
                obj.Select();
                obj.Sort(
                    obj.Columns[colDebut, Type.Missing], XlSortOrder.xlAscending,
                    obj.Columns[colDebut + 1, Type.Missing], Type.Missing, XlSortOrder.xlAscending,
                    obj.Columns[colDebut + 2, Type.Missing], XlSortOrder.xlAscending,
                    XlYesNoGuess.xlNo, Type.Missing, Type.Missing,
                    XlSortOrientation.xlSortColumns,
                    XlSortMethod.xlPinYin,
                    XlSortDataOption.xlSortNormal,
                    XlSortDataOption.xlSortNormal,
                    XlSortDataOption.xlSortNormal);

            }
            catch (Exception) { throw; }
        }

        public void PrintPageSetup(string zoneArea)
        {
            Worksheet feuille = (Worksheet)app.Workbooks[fileName].ActiveSheet;
            feuille.PageSetup.PrintArea = zoneArea;
        }

        #endregion
       
        #region Destructeur

        /// <summary>
        /// Detruit l'objet Excel
        /// </summary>
        ~Excel()
        {
            Dispose();
        }

        public void Dispose()
        {
            if (processId >= 0)
            {
                Process.GetProcessById(processId).Kill();
                processId = -1;
                app = null;
            }
        }

        #endregion

        #region Autres

        /// <summary>
        /// Obtient l'ID du processus
        /// </summary>
        /// <param name="ExcelProcessesBefore"></param>
        /// <param name="ExcelProcessesAfter"></param>
        /// <returns>ID</returns>
        private int GetProcessId(Process[] ExcelProcessesBefore, Process[] ExcelProcessesAfter)
        {
            bool IsMyProcess = false;
            int Result = -1;

            // Si mon processus est le seul à être instancié
            // inutile de parcourir le tableau, il n'y a qu'une seule instance :
            if (ExcelProcessesBefore.Length == 0 && ExcelProcessesAfter.Length == 1)
            {
                Result = ExcelProcessesAfter[0].Id;
            }
            else
            {
                // Parcours des processus après instanciation de l'objet :
                foreach (Process ProcessAfter in ExcelProcessesAfter)
                {
                    // Parcours des processus avant instanciation de l'objet :
                    IsMyProcess = true;
                    foreach (Process ProcessBefore in ExcelProcessesBefore)
                    {
                        // Si je le retrouve, ce n'est pas celui que je cherche :
                        if (ProcessAfter.Id == ProcessBefore.Id)
                        {
                            IsMyProcess = false;
                        }
                    }

                    // J'ai retrouvé mon processus :
                    if (IsMyProcess)
                    {
                        Result = ProcessAfter.Id;
                    }
                }
            }

            return Result;
        }

        #endregion
    }
}
